//package com.aliyun.messagemgt.application.service.Impl;
//
//import com.alibaba.fastjson.JSONArray;
//import com.alibaba.fastjson.JSONObject;
//import com.aliyun.messagemgt.application.service.AsyncService;
//import com.aliyun.messagemgt.application.service.PushEngine;
//import com.aliyun.messagemgt.util.MessageTypeUtil;
//import com.aliyun.messagemgt.common.constants.MonitorConstant;
//import com.aliyun.messagemgt.common.constant.PushConstant;
//import com.aliyun.messagemgt.dto.MonitorLog;
//import com.aliyun.messagemgt.dto.MsgSource;
//import com.aliyun.messagemgt.dto.PushChannelInfo;
//import com.aliyun.messagemgt.common.dto.foura.UserInfo;
//import com.aliyun.messagemgt.dto.push.MonitorInfo;
//import com.aliyun.messagemgt.dto.vo.MsgHandleLogResultVO;
//import com.aliyun.messagemgt.domain.repository.*;
//import com.aliyun.messagemgt.domain.repository.push.MonitorPushRepository;
//import com.aliyun.messagemgt.dto.in.*;
//import com.aliyun.messagemgt.common.enums.ChannelTypeEnum;
//import com.aliyun.messagemgt.common.errorcode.push.CommonErrorCode;
//import com.aliyun.messagemgt.common.exceptions.BaseException;
//import org.apache.commons.collections.CollectionUtils;
//import org.apache.commons.lang3.StringUtils;
//import org.apache.commons.lang3.time.DateUtils;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.data.redis.core.RedisTemplate;
//import org.springframework.scheduling.annotation.Async;
//import org.springframework.stereotype.Service;
//
//import javax.annotation.Resource;
//import java.util.*;
//import java.util.concurrent.TimeUnit;
//
///**
// * 监控通知
// * <p>
// * 三种监控规则：
// * a.监控消息源：只关注监控的消息源
// * b.监控渠道： 监控 渠道 下所有的 消息源
// * c.监控渠道类型：监控 a.渠道类型 下所有的 b.渠道 下所有的 c.消息源。
// * <p>
// * 场景：
// * 用户调用push接口，使用消息源A。进行消息推送。
// * 进入异步查询时候出发告警通知。
// * 1.查询该消息源被哪种规则监控到，上面的三种监控规则。
// * 1.没有被监控-跳过
// * 2.被监控到
// * 2.查询redis中是否存在该消息源（一定需要分类！这个目的是为了区分1.设置不同监控规则的失效时间。2.各种规则的告警次数，失效时间？）
// * [这里需要明确redis里存放消息源的目的]
// * 【【【【【【忽略了一点：设置的告警时间！】】】】】】
// * 3.查询告警通知次数是否达到告警次数上限
// * 1.达到上限。跳过
// * 2.没有，走下面lock逻辑
// * 这个过程lock()
// * 2.1 属于消息源监控：
// * 2.1.1.redis中是否有该消息源。
// * 1.有，取出redis中记录的时间，
// * 只查询本次消息源推送结果是否成功
// * 2.没有，把该消息源存入redis中，消息源id，该消息源此次发消息的时间，监控规则，以及设置失效时间。
// * 同样也是查询本次消息源
// * 2.1.2.查询发送消息结果的表，该消息源，指定时间规则内发送失败的结果集有多少？【逻辑优化】
// * 【这里想想是否可以优化。把原来查过的结果存入到redis中，只查询本次消息源推送结果失败的数量。避免被监控到的消息源每次都要重新查询一次。】
// * 1.结果集满足告警规则，发送告警。
// * 2.结果集不满足，跳过。
// * 2.1.3.发送告警之后，更新redis中告警次数+1.
// * <p>
// * 2.2 属于渠道监控
// * 2.2.1 redis中是否有该规则的消息源
// * 1.有，取出规则中记录的第一次时间
// * 2.没有，把该消息源存入规则消息源列表（列表应该包含1.消息源id，第一次记录的发送时间），公共信息都为监控规则，失效时间。失效为该规则渠道下所有的消息源都失效。
// * 2.2.2 取出该规则中所有的消息源。查询消息发送结果表？
// * 【这里想想是否可以优化。把原来查过的结果存入到redis中，只查询本次消息源推送结果是否成功。避免被监控到的消息源每次都要重新查询一次。】
// * 问题：如何查询本次调用的结果呢？
// * <p>
// * 2.3 属于渠道类型监控
// * 2.3.1 redis中有是否有该规则监控的消息源
// * 1.有，取出规则中记录的第一时间，(记录的失败次数，)
// * 其他规则下失败的次数，累加，看看是否满足告警规则。
// * 2.没有，把该消息源存入规则消息源列表
// * 这个过程unlock()
// * 【需要注意：当一个消息源满足多种监控规则时，每个监控规则都需要执行】
// *
// * @author byp
// * @date 2020/4/28
// */
//@SuppressWarnings("ALL")
//@Service("monitorPushServiceImpl")
//public class MonitorPushServiceImpl implements AsyncService {
//
//    @Resource
//    private MonitorPushRepository monitorRepository;
//    @Resource
//    private PushChannelRepository pushChannelRepository;
//    @Resource
//    private MsgHandleLogRepository msgHandleLogRepository;
//    @Resource
//    private IDaaSUserInfoRepository iDaasUserInfoRepository;
//    @Resource
//    private MsgSourceRepository msgSourceRepository;
//    @Resource
//    private MonitorLogRepository monitorLogRepository;
//    @Resource
//    private PushEngine pushEngine;
//    @Resource
//    private RedisTemplate redisTemplate;
//
//    //@Value("${ali.dysms.monitorSourceId}")
//    private String monitorSourceId;
//
//    /**
//     * 消息源 监控
//     */
//    private static final String MSG_SOURCE_MONITOR = "msgSourceMonitor";
//    /**
//     * 渠道名称 监控
//     */
//    private static final String CHANNEL_NAME_MONITOR = "channelNameMonitor";
//    /**
//     * 渠道类型 监控
//     */
//    private static final String CHANNEL_TYPE_MONITOR = "channelTypeMonitor";
//
//    /**
//     * 支持的监控告警渠道类型。目前只有短信和邮件（2020年6月11日）
//     */
//    private static final Integer[] SUPPORT_CHANNEL_TYPE = {4, 10};
//
//    private static final Logger logger = LoggerFactory.getLogger(MonitorPushServiceImpl.class);
//
//    @Async("asyncServiceExecutor")
//    @Override
//    public void monitorAsyncPush(List<MsgRecordVO> msgRecordVos, MsgSource msgSource) {
//        //1.查询当前消息源是否在监控范围内。监控渠道，那么渠道下的所有消息源都被监控
//        List<MonitorInfo> msgSourceMonitorInfoList = monitorRepository.queryMsgSourceMonitorInfos();
//        List<MonitorInfo> channelMonitorInfoList = monitorRepository.queryChannelMonitorInfos();
//        List<MonitorInfo> channelTypeMonitorInfoList = monitorRepository.queryChannelTypeMonitorInfos();
//
//        //消息源监控列表
//        boolean matchMonitorMsgSource = msgSourceMonitorInfoList.stream().anyMatch(monitorInfo ->
//                StringUtils.equals(msgSource.getSourceCode(), monitorInfo.getMonitorMsgSourceId()));
//        //渠道 数据库记录的是channel_id
//        boolean matchMonitorChannel = channelMonitorInfoList.stream().anyMatch(monitorInfo ->
//                msgSource.getPushChannelId().equals(monitorInfo.getMonitorChannelId()));
//        //渠道类型
//        boolean matchMonitorChannelType = channelTypeMonitorInfoList.stream().anyMatch(monitorInfo ->
//                msgSource.getPushChannelType().equals(monitorInfo.getMonitorChannelType()));
//
//        logger.info("是否匹配消息源监控：{},是否匹配渠道监控：{},是否匹配渠道类型监控：{}",
//                matchMonitorMsgSource, matchMonitorChannel, matchMonitorChannelType);
//
//        if (!matchMonitorMsgSource && !matchMonitorChannel && !matchMonitorChannelType) {
//            logger.info("{} 消息源没有被监控", msgSource.getSourceCode());
//            return;
//        } else {
//            //2.判断符合的监控类型 并在相应的监控类型中处理逻辑
//            if (matchMonitorMsgSource) {
//                //监控消息源
//                logger.info("{} 被消息源监控监控", msgSource.getSourceCode());
//                MonitorInfo msgSourceMonitor = msgSourceMonitorInfoList.stream().filter(monitorInfo ->
//                        StringUtils.equals(msgSource.getSourceCode(), monitorInfo.getMonitorMsgSourceId())).findAny().orElse(null);
//                if (msgSourceMonitor != null) {
//                    String redisKey = MSG_SOURCE_MONITOR + "_" + msgSource.getSourceCode();
//                    //监控中没有直接返回false 不告警
//                    boolean executeMsgSourceMonitor = this.executeMonitor(msgSourceMonitor, redisKey);
//                    if (executeMsgSourceMonitor) {
//                        //3.满足告警 需要发送告警
//                        monitorPush(msgSourceMonitor, redisKey);
//                    }
//                }
//
//            }
//            if (matchMonitorChannel) {
//                logger.info("{} 被渠道名称监控监控", msgSource.getSourceCode());
//                //这里理论上只有一个
//                MonitorInfo channelNameMonitor = channelMonitorInfoList.stream().filter(monitorInfo ->
//                        msgSource.getPushChannelId().equals(monitorInfo.getMonitorChannelId())).findAny().orElse(null);
//                if (channelNameMonitor != null) {
//                    String redisKey = CHANNEL_NAME_MONITOR + "_" + msgSource.getPushChannelId();
//                    boolean executeChannelNameMonitor = this.executeMonitor(channelNameMonitor, redisKey);
//                    if (executeChannelNameMonitor) {
//                        //3.满足告警 需要发送告警
//                        monitorPush(channelNameMonitor, redisKey);
//                    }
//                }
//            }
//            if (matchMonitorChannelType) {
//                logger.info("{} 被渠道类型监控监控", msgSource.getSourceCode());
//                MonitorInfo channelTypeMonitor = channelTypeMonitorInfoList.stream().filter(monitorInfo ->
//                        msgSource.getPushChannelType().equals(monitorInfo.getMonitorChannelType())).findAny().orElse(null);
//                if (channelTypeMonitor != null) {
//                    String redisKey = CHANNEL_TYPE_MONITOR + "_" + msgSource.getPushChannelType();
//                    boolean executeChannelNameMonitor = this.executeMonitor(channelTypeMonitor, redisKey);
//                    if (executeChannelNameMonitor) {
//                        //3.满足告警 需要发送告警
//                        monitorPush(channelTypeMonitor, redisKey);
//                    }
//                }
//            }
//        }
//    }
//
//    /**
//     * 发送监控告警
//     * 2020年6月16日 暂时只发送短信告警
//     *
//     * @param monitorInfo 告警信息
//     * @param redisKey    redis中的key
//     */
//    private void monitorPush(MonitorInfo monitorInfo, String redisKey) {
//        String reporter = monitorInfo.getReporter();
//        if (reporter == null || reporter.length() == 0) {
//            throw new BaseException(CommonErrorCode.MONITOR_EXPIRE);
//        }
//        JSONArray reporterJson = JSONArray.parseArray(reporter);
//        logger.info("推送人为 {}", reporterJson);
//        //这里获得到的key为用户user_code 通过用户编码获取到用户信息。然后再根据监控告警设置的渠道去设置这里填什么值。
//        Integer reportChannelId = monitorInfo.getReportChannelId();
//        PushChannelInfo reportChannel = pushChannelRepository.queryPushChannelInfoByChannelId(reportChannelId);
//        if (!Arrays.asList(SUPPORT_CHANNEL_TYPE).contains(reportChannel.getChannelType())) {
//            logger.info("告警渠道类型仅支持短信和邮件，暂不支持该种渠道类型");
//            throw new BaseException(CommonErrorCode.MONITOR_UNSUPPORTED_EXPIRE);
//        }
//        List<Receiver> receivers = this.dealReceiver(reportChannel.getChannelType(), reporterJson);
//        List<FourAObjectEntity> pushUsers = this.dealPushUser(reportChannel.getChannelType(), reporterJson);
//        StringBuilder monitorMsg = new StringBuilder();
//        Byte monitorType = monitorInfo.getMonitorType();
//        switch (monitorType) {
//            case 1:
//                monitorMsg.append("您监控的消息源:").append(monitorInfo.getMsgSourceName()).append("，推送失败次数已达告警次数。");
//                break;
//            case 2:
//                monitorMsg.append("您监控的渠道:").append(monitorInfo.getChannelName()).append("，推送失败次数已达告警次数。");
//                break;
//            case 3:
//                monitorMsg.append("您监控的渠道类型:").append(dealChannelType(monitorInfo.getMonitorChannelType())).append("，推送失败次数已达告警次数。");
//                break;
//            default:
//                break;
//        }
//        JSONObject template = new JSONObject();
//        template.put("content", monitorMsg);
//        MsgBody text = new MsgBody().setType("TEXT").setContent(JSONObject.toJSONString(template));
//        MsgRecordVO msgRecordVO = new MsgRecordVO().setMessageType(MessageTypeUtil.generateWechatTextCardMsg())
//                .setMsgTitle(PushConstant.MONITOR_MSG_TITLE)
//                .setMsgDescription(PushConstant.MONITOR_MSG_DESCROPTION)
//                .setCommentType(PushConstant.TEXT_COMMENT_TYPE)
//                .setMsgSourceType(PushConstant.MONITOR_MSG_SOURCE_TYPE)
//                .setPushChannelId(Long.valueOf(monitorInfo.getReportChannelId()))
//                .setPushChannelName(monitorInfo.getReportChannelName())
//                .setOwnerDept(monitorInfo.getOwnerDept())
//                .setOwnerDeptName(monitorInfo.getOwnerDeptName())
//                .setReceivers(receivers)
//                .setPushUserIds(pushUsers)
//                .setContents(Collections.singletonList(text));
//        //这里填充告警主体，选择一个可用的短信消息源或者邮件消息源。
////        this.dealMsgRecordVO(reportChannel.getChannelType(), msgRecordVO);
//        logger.info("当前告警，发送报告的渠道类型为：{}，设置的消息源sourceId为：{}", reportChannel.getChannelType(), monitorSourceId);
//        msgRecordVO.setMsgSourceId(monitorSourceId);
//        //如果是邮件告警这里需要添加邮件告警主题
//        if (Objects.equals(reportChannel.getChannelType(), ChannelTypeEnum.MAIL.getType())) {
//            logger.info("邮件告警，设置邮件主题");
//            msgRecordVO.setSubject(PushConstant.MONITOR_MSG_TITLE);
//        }
//        pushEngine.push(Collections.singletonList(msgRecordVO));
//        //保存到monitor_log中
//        logger.info("监控发送记录保存到monitor_log中，begin");
//        this.saveMonitorLog(msgRecordVO, monitorInfo);
//        logger.info("监控发送记录保存到monitor_log中，end");
//        //推送之后，修改redis中的记录
//        JSONObject data = (JSONObject) redisTemplate.opsForValue().get(redisKey);
//        logger.info("推送之后需要更新redis中的记录。data：{}", data.toJSONString());
//        data.put("lastMonitorTime", System.currentTimeMillis());
//        logger.info("更新redis中lastMonitorTime记录后，data：{}", data.toJSONString());
//        //更新redis不改变失效时间
//        redisTemplate.opsForValue().set(redisKey, data, 0);
//    }
//
//    /**
//     * 执行监控逻辑
//     * 这里应该梳理清楚 1.不触发告警 2.不再告警
//     * 1.不触发告警：就是没达到告警的条件
//     * 2.不再告警：告警已达到设置的规则上限
//     *
//     * @param monitorInfo 查询到的监控
//     * @param redisKey    redis中保存的key
//     * @return 是否应该告警
//     */
//    private boolean executeMonitor(MonitorInfo monitorInfo, String redisKey) {
//        if (monitorInfo.getLimitValue() == null || monitorInfo.getLimitValue() <= 0) {
//            logger.info("未设置分发失败次数，无法告警。返回false不再告警");
//            return false;
//        }
//        //1.从redis中获取该监控类型记录的监控信息。
//        JSONObject data = (JSONObject) redisTemplate.opsForValue().get(redisKey);
//        if (data == null) {
//            //2.1没有该监控信息。可能情况：a.第一次走该方法。 b.上次一监控周期完成。redis数据失效。
//            //这里需要把当前的告警配置数据初始化放入redis中。
//            logger.info("2.1 redis中没有监控，初始化监控信息到redis");
//            JSONObject jsonObject = new JSONObject();
//            //周期内第一次执行到监控的时间。（这个的作用是为了判断从周期开始时间 至 周期范围内 执行失败的记录有没有触发告警）
//            jsonObject.put("monitorCycleBeginTime", new Date());
//            //设置上一次告警时间毫秒数（这个的作用是为了判断限制单位时间内不再告警）
//            jsonObject.put("lastMonitorTime", 0L);
//            //规则设置中 触发告警规则2-1小时 3-1天
//            int limitUnit = monitorInfo.getLimitUnit();
//            if (limitUnit == MonitorConstant.LIMIT_UNIT_HOUR) {
//                redisTemplate.opsForValue().set(redisKey, jsonObject, 1, TimeUnit.HOURS);
//            }
//            if (limitUnit == MonitorConstant.LIMIT_UNIT_DAY) {
//                //这里没有按照日期的一天时间计算，而是用消息源发送消息开始的时间开始往后的1天。
//                redisTemplate.opsForValue().set(redisKey, jsonObject, 1, TimeUnit.DAYS);
//            }
//            return false;
//        } else {
//            logger.info("3.redis中存在该告警规则的数据");
//            //3.redis中存在该告警规则的数据
//            //3.1判断是否符合不再告警的时间周期（这里直接用毫秒吧，存的时候也统一一下）
//            Long lastMonitorTime = data.getLongValue("lastMonitorTime");
//            boolean isRestrain = this.isRestrain(lastMonitorTime, monitorInfo);
//            logger.info("3.1判断是否符合不再告警，返回值:{}", isRestrain);
//            if (isRestrain) {
//                logger.info("符合不再告警");
//                return false;
//            }
//            //3.2查询数据库中指定a.该消息源 b.监控时间段范围 执行失败的数据量。
//            List<MsgHandleLogResultVO> handleLogResultVOList = this.queryErrorMonitorHandleLogs(monitorInfo, data);
//            if(CollectionUtils.isNotEmpty(handleLogResultVOList)){
//            logger.info("3.2查询数据库中指定a.该监控类型{} b.监控时间段范围 执行失败的数据量为：{}", monitorInfo.getMonitorType(), handleLogResultVOList.size());
//            int limitValue = monitorInfo.getLimitValue();
//            if (handleLogResultVOList.size() > limitValue) {
//                logger.info("该监控类型执行失败的次数：{} ,超过设置的告警次数：{} ,需要告警", handleLogResultVOList.size(), limitValue);
//                return true;
//            }
//            logger.info("该监控类型执行失败的次数：{} ,未超过设置的告警次数：{} ,不需要告警", handleLogResultVOList.size(), limitValue);
//            }
//            return false;
//        }
//    }
//
//    /**
//     * 判断是否符合不再告警的时间周期
//     * 2020年7月30日09:48:17 发现可以不设置不在告警。如果不在告警规则为空，说明一直告警
//     *
//     * @param lastMonitorTime 上一次告警时间
//     * @param monitorInfo     告警规则类
//     * @return 是否符合不再告警
//     */
//    private boolean isRestrain(Long lastMonitorTime, MonitorInfo monitorInfo) {
//        //不再告警规则 1-分钟 2-小时 3-天
//        int restrainUnit = monitorInfo.getRestrainUnit();
//        if (monitorInfo.getRestrainValue() != null && monitorInfo.getRestrainValue() > 0) {
//            //不再告警单位值
//            int restrainValue = monitorInfo.getRestrainValue();
//            Long judgeTime;
//            if (restrainUnit == MonitorConstant.RESTRAIN_UNIT_MINUTE) {
//                judgeTime = (long) (restrainValue * 60 * 1000);
//            } else if (restrainUnit == MonitorConstant.RESTRAIN_UNIT_HOUR) {
//                judgeTime = (long) (restrainValue * 60 * 60 * 1000);
//            } else if (restrainUnit == MonitorConstant.RESTRAIN_UNIT_DAY) {
//                judgeTime = (long) (restrainValue * 24 * 60 * 60 * 1000);
//            } else {
//                judgeTime = 0L;
//            }
//            Long now = System.currentTimeMillis();
//            Long diff = now - lastMonitorTime;
//            return diff <= judgeTime;
//        }
//        return false;
//    }
//
//    /**
//     * 获取操作失败的数据集合
//     *
//     * @param monitorInfo 监控信息
//     * @param data        redis中的data数据
//     * @return 日志集合
//     */
//    private List<MsgHandleLogResultVO> queryErrorMonitorHandleLogs(MonitorInfo monitorInfo, JSONObject data) {
//        Date beginTime = data.getDate("monitorCycleBeginTime");
//        //规则设置中 触发告警规则2-1小时 3-1天
//        int limitUnit = monitorInfo.getLimitUnit();
//        Date endTime;
//        if (limitUnit == MonitorConstant.LIMIT_UNIT_HOUR) {
//            endTime = DateUtils.addHours(beginTime, 1);
//        } else {
//            endTime = DateUtils.addDays(beginTime, 1);
//        }
//        List<MsgHandleLogResultVO> result = null;
//        Byte monitorType = monitorInfo.getMonitorType();
//        switch (monitorType) {
//            case 1:
//                result = msgHandleLogRepository.queryErrorMsgHandleLogsBySourceId(monitorInfo.getMonitorMsgSourceId(), beginTime, endTime);
//                break;
//            case 2:
//                result = msgHandleLogRepository.queryErrorMsgHandleLogsByChannelName(monitorInfo.getMonitorChannelId(), beginTime, endTime);
//                break;
//            case 3:
//                result = msgHandleLogRepository.queryErrorMsgHandleLogsByChannelType(monitorInfo.getMonitorChannelType(), beginTime, endTime);
//                break;
//            default:
//                break;
//        }
//        return result;
//    }
//
//    /**
//     * 处理receiver
//     *
//     * @param channelType  渠道类型
//     * @param reporterJson 监控信息中的报告人
//     * @return list
//     */
//    private List<Receiver> dealReceiver(Integer channelType, JSONArray reporterJson) {
//        List<Receiver> receiverList = new ArrayList<>();
//        Receiver receiver;
//        switch (channelType) {
//            case 4:
//                for (int i = 0; i < reporterJson.size(); i++) {
//                    receiver = new Receiver();
//                    JSONObject rep = reporterJson.getJSONObject(i);
//                    //这里获得到的key为用户user_code 通过用户编码获取到用户信息。然后
//                    String userCode = rep.getString("key");
//                    UserInfo userInfo = iDaasUserInfoRepository.queryUserByUserCode(userCode);
//                    receiver.setReceiverId(userInfo.getUserMobile());
//                    receiver.setReceiverName(rep.getString("name"));
//                    receiver.setReceiverType(PushConstant.USER_RECEIVER);
//                    receiverList.add(receiver);
//                }
//                break;
//            case 10:
//                //邮件
//                for (int i = 0; i < reporterJson.size(); i++) {
//                    receiver = new Receiver();
//                    JSONObject rep = reporterJson.getJSONObject(i);
//                    //这里获得到的key为用户user_code 通过用户编码获取到用户信息。然后
//                    String userCode = rep.getString("key");
//                    UserInfo userInfo = iDaasUserInfoRepository.queryUserByUserCode(userCode);
//                    receiver.setReceiverId(userInfo.getOfficeEmail());
//                    receiver.setReceiverName(rep.getString("name"));
//                    receiver.setReceiverType(PushConstant.USER_RECEIVER);
//                    receiverList.add(receiver);
//                }
//                break;
//            default:
//                break;
//        }
//        return receiverList;
//    }
//
//    /**
//     * 封装监控告警接收者
//     *
//     * @param channelType  监控告警渠道类型
//     * @param reporterJson 监控信息中的报告人
//     * @return 封装的告警人员
//     */
//    private List<FourAObjectEntity> dealPushUser(Integer channelType, JSONArray reporterJson) {
//        List<FourAObjectEntity> pushUser = new ArrayList<>();
//        FourAObjectEntity receiver;
//        switch (channelType) {
//            case 4:
//                for (int i = 0; i < reporterJson.size(); i++) {
//                    receiver = new FourAObjectEntity();
//                    JSONObject rep = reporterJson.getJSONObject(i);
//                    //这里获得到的key为用户user_code 通过用户编码获取到用户信息。然后
//                    String userCode = rep.getString("key");
//                    UserInfo userInfo = iDaasUserInfoRepository.queryUserByUserCode(userCode);
//                    receiver.setKey(userInfo.getUserMobile());
//                    receiver.setName(rep.getString("name"));
//                    pushUser.add(receiver);
//                }
//                break;
//            case 10:
//                //邮件
//                for (int i = 0; i < reporterJson.size(); i++) {
//                    receiver = new FourAObjectEntity();
//                    JSONObject rep = reporterJson.getJSONObject(i);
//                    //这里获得到的key为用户user_code 通过用户编码获取到用户信息。然后
//                    String userCode = rep.getString("key");
//                    UserInfo userInfo = iDaasUserInfoRepository.queryUserByUserCode(userCode);
//                    receiver.setKey(userInfo.getOfficeEmail());
//                    receiver.setName(rep.getString("name"));
//                    pushUser.add(receiver);
//                }
//                break;
//            default:
//                break;
//        }
//        return pushUser;
//    }
//
//    /**
//     * 转换渠道类型显示名称
//     *
//     * @param monitorChannelType 渠道类型
//     * @return 名称
//     */
//    private String dealChannelType(Integer monitorChannelType) {
//        String msg = "";
//        switch (monitorChannelType) {
//            case 4:
//                msg = "短信";
//                break;
//            case 6:
//                msg = "系统端";
//                break;
//            case 7:
//                msg = "钉钉";
//                break;
//            case 8:
//            case 9:
//                msg = "小程序";
//                break;
//            case 10:
//                msg = "邮件";
//                break;
//            case 20:
//                msg = "移动开发mPaaS";
//                break;
//            default:
//                break;
//        }
//        return msg;
//    }
//
//    /**
//     * 添加告警报告使用的渠道
//     *
//     * @param channelType 渠道类型
//     * @param msgRecordVO 创建的告警报告vo
//     */
////    private void dealMsgRecordVO(Integer channelType, MsgRecordVO msgRecordVO) {
////        List<MsgSource> msgSourceList = msgSourceMapper.queryAvailableMsgSources(channelType);
////        if (CollectionUtils.isEmpty(msgSourceList)) {
////            throw new BaseException(CommonErrorCode.MONITOR_UNAVAILABLE_MSG_SOURCE);
////        }
////        MsgSource msgSource = msgSourceList.stream().findFirst().orElse(null);
////        if (msgSource != null) {
////            logger.info("当前告警，发送报告的渠道类型为：{}，设置的消息源sourceId为：{}", channelType, msgSource.getSourceId());
////            msgRecordVO.setMsgSourceId(msgSource.getSourceId());
////        }
////    }
//
//    /**
//     * 保存到监控日志中
//     *
//     * @param msgRecordVO 消息体
//     * @param monitorInfo 监控
//     */
//    private void saveMonitorLog(MsgRecordVO msgRecordVO, MonitorInfo monitorInfo) {
//        MonitorLog monitorLog = new MonitorLog();
//        monitorLog.setMonitorTitle(msgRecordVO.getMsgTitle());
//        monitorLog.setMonitorContent(msgRecordVO.getContents().get(0).getContent());
//        monitorLog.setPushChannelId(Math.toIntExact(msgRecordVO.getPushChannelId()));
//        monitorLog.setPushChannelName(msgRecordVO.getPushChannelName());
//        monitorLog.setPushChannelType(msgRecordVO.getPushChannelType());
//        monitorLog.setPushTime(new Date());
//        monitorLog.setOwner(monitorInfo.getOwner());
//        monitorLog.setOwnerDept(monitorInfo.getOwnerDept());
//        monitorLog.setOwnerDeptName(monitorInfo.getOwnerDeptName());
//        String msgSourceId = msgRecordVO.getMsgSourceId();
//        MsgSource msgSource = msgSourceRepository.getMsgSourceById(msgSourceId);
//        monitorLog.setMsgId(Math.toIntExact(msgSource.getMsgSourceId()));
//        monitorLog.setMsgSourceId(msgSourceId);
//        monitorLog.setMsgSourceName(msgSource.getSourceName());
//        monitorLog.setMsgSourceType(msgSource.getMessageType());
//        monitorLog.setMonitorId(monitorInfo.getMonitorId());
//        monitorLog.setReceiverId(msgRecordVO.getReceivers().toString());
//        MsgMiddleResult result = msgRecordVO.getResults().get(0);
//        if (result != null) {
//            monitorLog.setPushResultCode(result.getPushResultCode());
//            monitorLog.setPushResultDescription(result.getPushResultDescription());
//        }
//
//        monitorLogRepository.insertSelective(Collections.singletonList(monitorLog));
//    }
//
//}
